package com.atguigu.gulimall.product.config;

import org.bouncycastle.util.io.pem.PemObjectParser;
import org.redisson.misc.Hash;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/**
 * ClassName: ddd
 * Package： com.atguigu.gulimall.product.config
 * Description:
 *
 * @Author: Sweng
 * @Create: 2025/4/17 - 10:14
 * VERSION: version1.0
 **/
public class ddd extends test{



    static class Person implements Comparable<Person>{
        private int age;

        private String name;
        public Person(int age,String name){
            this.age = age;
            this.name = name;
        }


        @Override
        public int compareTo(Person o) {
            //年龄升序  然后按照名称降序
            if(this.age > o.age){
                return 1;
            }else if(this.age < o.age){
                return -1;
            }else{
                return this.name.compareTo(o.name) * -1;
            }
        }

        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    ddd(){
        super();
        this.testAbstract();
    }

    public static void main(String[] args) throws FileNotFoundException {



        Person sweng = new Person(19, "sweng");
        Person sweng1 = new Person(19, "sweng1");
        Person sweng2 = new Person(19, "sweng2");

        Person changsan = new Person(20, "changsan");
        Person erli = new Person(30, "erli");

        ArrayList<Person> people = new ArrayList<>();
        people.add(changsan);
        people.add(erli);
        people.add(sweng);
        people.add(sweng1);
        people.add(sweng2);


        int[] arr = {1,2,1,3};

        System.out.println("sss======"+1%1000000007);

//        Collections.sort(people);
//
//        Collections.sort(people,(o1,o2)->o1.compareTo(o2));

        sortF(arr);
        for(int a : arr){
            System.out.println(a);
        }

        InsertSort(people.toArray(new Person[]{}));

        System.out.println(people.toString());


    }
    public void exchange(String s ,char[] d){
        s.replaceAll("[a-z]+","*");
        d[0] = 'w';
    }


    @Override
    public void testAbstract(){

    }


    /*
        直接排序
        经过n-1趟比较。 每次比较出最小的数值，每趟比较出最小的数值。然后放在第一位。依次比较n-1次
     */

    public static void selectSort(Person[] arr){

        int length = arr.length;
        //这个是趟数。总共要进行n-1次比较
        for (int i = 0; i < length-1; i++) {
            //记录本趟最小的数值的索引位置。
            int curMin = i;
            for (int j = i+1; j < length; j++) {

                //根据上面重写方法。 第一个为 大于 第二位 真值. 则把J 设为当前轮的最小值
                if(arr[curMin].compareTo(arr[j])>0){
                    curMin = j;
                }
            }
            //第一个不是最小的 交换位置
            if(curMin != i){
                Person tmp = arr[i];
                arr[i] = arr[curMin];
                arr[curMin] = tmp;
            }
            System.out.println(Arrays.toString(arr));
        }

    }

    public static void PopSort(Person[] arr){

        int length = arr.length;

        //冒泡的趟数
        for (int i = 0;i<length-1;i++){

            //标记本趟是否有交换位置。如果没有交换 则说明已经排好序了 可以直接结束排序
            boolean flag = false;

            //每一趟的比较次数。 每趟比较过后最大的数值会放在最后一位。 所以每次比较的次数要减少一次
            for (int j = 0; j < length - 1 -i; j++) {
                //如果前面的数值比后面的大 就交换位置
                if(arr[j].compareTo(arr[j+1]) > 0){
                    Person tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    flag = true;
                }
            }

            System.out.println(Arrays.toString(arr));
            if(!flag)
                break;
        }

    }


    public static void InsertSort(Person[]  arr){
        int length = arr.length;

        for (int i = 1; i < length; i++) {
            //记录当前排序的数值
            Person curSort = arr[i];

            if(arr[i-1].compareTo(arr[i])>0){
                int j = i-1;
                //若果和sortValue 比较大于 交换位置、 向前面移动一个位置
                for (; j >=0 && arr[j].compareTo(curSort)>0 ; j--) {
                    arr[j+1] = arr[j];
                }
                //找到位置。 把当前排序的数值放到正确的位置上
                arr[j+1] = curSort;
            }
            System.out.println(Arrays.toString(arr));
        }

    }

    //总结
    public static void aa(Person[] arr){

        for (int i = 0; i < arr.length-1; i++) {

            boolean flag = false;
            for (int j = 0; j < arr.length - i - 1; j++) {
                if(arr[j].compareTo(arr[j+1])>0) {
                    Person temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
                if(!flag)
                    break;
            }
        }
    }

    //单存比较 最小的放在第一位值

    public static void bb(Person[] arr){

        for (int i = 0; i < arr.length - 1; i++) {
            int curMin = i;
            for (int j = i+1; j < arr.length -1; j++) {
                //找到最小的值
                if(arr[curMin].compareTo(arr[j]) > 0){
                    curMin = j;
                }
            }

            //开始交换i 和 curMIn 最小值的位置
            if(curMin != i){
                Person temp = arr[i];
                arr[i] = arr[curMin];
                arr[curMin] = temp;
            }
        }
    }

    //插入排序
    public static void cc(Person[] arr){
        for (int i = 1; i < arr.length ; i++) {

            Person curSort = arr[i];
            if(arr[i-1].compareTo(arr[i]) > 0) {
                int j = i - 1;
                for (; j >= 0 && arr[j].compareTo(curSort)>0; j--) {
                        arr[j+1] = arr[j];
                }
                arr[j+1]=curSort;
            }
        }
    }

    //二分查找

    /**
     *
     *  在一个二维数组array中（每个一维数组的长度相同），
     *  每一行都按照从左到右递增的顺序排序，
     *  每一列都按照从上到下递增的顺序排序。
     *  请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
     *
     *  条件是 右边的长度 大于左边继续循环
     */
    public static int search (int[] nums, int target) {
        // write code here

        if(nums  == null || nums.length ==0){
            return -1;
        }

        int rightLength = nums.length-1;
        int leftLength = 0;

        while(rightLength >= leftLength){

            //int middle = leftLength + (rightLength  - leftLength )/2;
            int middle = (rightLength  + leftLength )/2;

            if(nums[middle] > target){
                rightLength = middle-1;
            }else if(nums[middle] < target){
                leftLength = middle+1;
            }else{
                return middle;
            }

        }

        return -1;
    }

    public static void sortF(int[] array){
        int[] tempArray = new int[array.length];
        mergeSortF(array,tempArray,0,array.length-1);
    }

    public static void mergeSortFLearn(int[] array,int[] tempArray,int begin,int end){

        while(begin < end) {

            int middle = begin + ((end-begin)>>2);
            mergeSortFLearn(array,tempArray,begin,middle);
            mergeSortFLearn(array,tempArray,middle+1,end);

            mergeLearn(array,tempArray,begin,middle,end);

        }

    }

    public static void mergeLearn(int[] array,int[] tempArray,int begin,int mid,int end){
        tempArray = array;
        int leftPost = begin;
        int rightPost = mid+1;
        int tempArrayPos = begin;

        while(leftPost <=mid && rightPost <= end){
            if(tempArray[leftPost] < tempArray[rightPost]){
                tempArray[tempArrayPos++] = tempArray[leftPost++];
            }else if(tempArray[leftPost] > tempArray[rightPost]){
                tempArray[tempArrayPos++] = tempArray[rightPost++];
            }
        }


            while(leftPost <= mid){
                tempArray[tempArrayPos++] = tempArray[leftPost++];
            }



            while(rightPost <= end){
                tempArray[tempArrayPos++] = tempArray[rightPost++];
            }


        for (int i = begin; i <= end; i++) {
            array[i] = tempArray[i];
        }

    }
    public static void mergeSortF(int[] array,int[] tempArray,int begin,int end){
        if(begin < end){
            int mid = begin + ((end-begin)>>1);
            mergeSortF(array,tempArray,begin,mid);
            mergeSortF(array,tempArray,mid+1,end);

            merge(array,tempArray,begin,mid,end);
        }


    }

    public static void merge(int[] array,int[] tempArray,int begin,int mid,int end){
        int leftPos = begin;
        int rightPos = mid+1;
        int tempArrayPos = begin;

        while (leftPos <= mid && rightPos <=end){
            if(array[leftPos] < array[rightPos]){
                tempArray[tempArrayPos++] = array[leftPos++];
            }else{
                tempArray[tempArrayPos++] = array[rightPos++];
            }
        }

        while(leftPos <= mid){
            tempArray[tempArrayPos++] = array[leftPos++];
        }

        while (rightPos <= end){
            tempArray[tempArrayPos++]  = array[rightPos++];
        }

        for (int i = begin; i <= end; i++) {
            array[i] = tempArray[i];
        }

    }






}
